// app/controller/brand_controller.js
'use strict';

const Controller = require('egg').Controller;

class BrandController extends Controller {
  // 获取所有启用的品牌列表
  async getBrands() {
    const { ctx } = this;
    
    try {
      const brands = await ctx.model.BrandModel.findAll({
        where: {
          status: 'active'
        },
        order: [['id', 'ASC']]
      });
      
      ctx.success(brands);
    } catch (error) {
      ctx.logger.error('获取品牌列表失败:', error);
      ctx.error(`获取品牌列表失败: ${error.message}`);
    }
  }
  
  // 获取品牌详情
  async getBrand() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      const brand = await ctx.model.BrandModel.findByPk(id);
      
      if (!brand) {
        ctx.error('品牌不存在', 404);
        return;
      }
      
      ctx.success(brand);
    } catch (error) {
      ctx.logger.error('获取品牌详情失败:', error);
      ctx.error(`获取品牌详情失败: ${error.message}`);
    }
  }
  
  // 创建品牌
  async createBrand() {
    const { ctx } = this;
    const brandData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      const validation = ctx.service.validationService.validateCreateBrand(brandData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      // 验证品牌名称唯一性
      const existingBrand = await ctx.model.BrandModel.findOne({
        where: { name: brandData.name }
      });
      
      if (existingBrand) {
        ctx.error('品牌名称已存在', 400);
        return;
      }
      
      // 创建品牌
      const brand = await ctx.model.BrandModel.create(brandData);
      
      ctx.success(brand, '品牌创建成功');
    } catch (error) {
      ctx.logger.error('创建品牌失败:', error);
      ctx.error(`创建品牌失败: ${error.message}`);
    }
  }
  
  // 更新品牌
  async updateBrand() {
    const { ctx } = this;
    const { id } = ctx.params;
    const updateData = ctx.request.body;
    
    try {
      // 使用Joi验证服务进行参数验证
      // 首先验证ID
      const idValidation = ctx.service.validationService.validateId(parseInt(id));
      if (idValidation.error) {
        ctx.error(`参数验证失败: ${idValidation.error.message}`);
        return;
      }
      
      // 验证品牌数据
      const validation = ctx.service.validationService.validateUpdateBrand(updateData);
      if (validation.error) {
        ctx.error(`参数验证失败: ${validation.error.message}`);
        return;
      }
      
      const brand = await ctx.model.BrandModel.findByPk(id);
      
      if (!brand) {
        ctx.error('品牌不存在', 404);
        return;
      }
      
      // 如果更新品牌名称，验证唯一性
      if (updateData.name && updateData.name !== brand.name) {
        const existingBrand = await ctx.model.BrandModel.findOne({
          where: { name: updateData.name }
        });
        
        if (existingBrand) {
          ctx.error('品牌名称已存在', 400);
          return;
        }
      }
      
      // 更新品牌
      await brand.update(updateData);
      
      ctx.success(brand, '品牌更新成功');
    } catch (error) {
      ctx.logger.error('更新品牌失败:', error);
      ctx.error(`更新品牌失败: ${error.message}`);
    }
  }
  
  // 删除品牌
  async deleteBrand() {
    const { ctx } = this;
    const { id } = ctx.params;
    
    try {
      const brand = await ctx.model.BrandModel.findByPk(id);
      
      if (!brand) {
        ctx.error('品牌不存在', 404);
        return;
      }
      
      // 检查是否有产品关联此品牌
      const productCount = await ctx.model.ProductModel.count({
        where: { brandId: id }
      });
      
      if (productCount > 0) {
        ctx.error('该品牌下有关联产品，无法删除', 400);
        return;
      }
      
      // 删除品牌
      await brand.destroy();
      
      ctx.success(null, '品牌删除成功');
    } catch (error) {
      ctx.logger.error('删除品牌失败:', error);
      ctx.error(`删除品牌失败: ${error.message}`);
    }
  }
}

module.exports = BrandController;